{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 使用torch.nn实现二维卷积实验+超参数对比实验+空洞卷积实验"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "962\n",
      "340\n",
      "torch.Size([3, 64, 64])\n",
      "{'bus': 0, 'car': 1, 'truck': 2}\n",
      "torch.Size([3, 64, 64])\n",
      "{'bus': 0, 'car': 1, 'truck': 2}\n"
     ]
    }
   ],
   "source": [
    "from torchvision.datasets import ImageFolder\n",
    "import torch.utils.data as Data\n",
    "import torchvision.transforms as transforms\n",
    "import  time#导入模块\n",
    "import torch.nn as nn\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import numpy as np\n",
    "data_transform = transforms.Compose([\n",
    "    transforms.Resize((64,64)),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize(mean=[0.5,0.5,0.5], std=[0.5, 0.5, 0.5])\n",
    "])\n",
    "BATCH_SIZE = 128\n",
    "train_dataset = ImageFolder(\"vehicle_dataset_new/training_dataset\",transform = data_transform)\n",
    "train_loader = Data.DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "\n",
    "test_dataset = ImageFolder(\"vehicle_dataset_new/test_dataset\",transform = data_transform)\n",
    "test_loader = Data.DataLoader(dataset=test_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "print(len(train_dataset))\n",
    "print(len(test_dataset))\n",
    "print(train_dataset[0][0].size())\n",
    "print(train_dataset.class_to_idx)\n",
    "print(test_dataset[0][0].size())\n",
    "print(test_dataset.class_to_idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvModule(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(ConvModule, self).__init__()\n",
    "        self.conv = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=1, padding=0),\n",
    "            nn.BatchNorm2d(32),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=0),\n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=0),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(inplace=True),\n",
    "        )\n",
    "        self.fc = nn.Linear(128, num_classes)  # 上一层(avg_pool2d)输出为(16,128,3,2) \n",
    "#         self.fc = nn.Linear(128*3*2, num_classes)  # 上一层(avg_pool2d)输出为(16,128,3,2) \n",
    "    def forward(self, X):\n",
    "        # print(X.shape)\n",
    "        out = self.conv(X)\n",
    "#         print(out.shape)\n",
    "        out = F.avg_pool2d(out, kernel_size=30)  # 平均池化层将图片的大小变为1*1\n",
    "#         print(out.shape)\n",
    "        out = out.squeeze()  # squeeze去除所有item数量为1的维度\n",
    "#         out = out.flatten(start_dim=1)  # flatten 将高维向量展平为 2 维向量\n",
    "        # out = out.view(-1, 128)\n",
    "        # print(out.shape)\n",
    "        out = self.fc(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_epoch(net, data_loader, device):\n",
    "    net.train()\n",
    "    train_batch_num = len(data_loader)\n",
    "    total_loss = 0\n",
    "    correct = 0\n",
    "    sample_num = 0\n",
    "\n",
    "    for batch_idx, (data, target) in enumerate(data_loader):\n",
    "        # print(data)\n",
    "        # print(target)\n",
    "        data = data.to(device).float()\n",
    "        target = target.to(device).long()\n",
    "        optimizer.zero_grad()\n",
    "        output = net(data)\n",
    "        loss = criterion(output, target)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        total_loss += loss.item()\n",
    "        prediction = torch.argmax(output, 1)\n",
    "#         print(\"output\", output)\n",
    "#         print(\"prediction\", prediction)\n",
    "#         print(\"target\", target)\n",
    "        correct += (prediction == target).sum().item()\n",
    "        sample_num += len(prediction)\n",
    "    loss = total_loss / train_batch_num\n",
    "    acc = correct / sample_num\n",
    "    return loss, acc\n",
    "\n",
    "def test_epoch(net, data_loader, device):\n",
    "    net.eval()\n",
    "    test_batch_num = len(data_loader)\n",
    "    total_loss = 0\n",
    "    correct = 0\n",
    "    sample_num = 0\n",
    "    with torch.no_grad():\n",
    "        for batch_idx, (data, target) in enumerate(data_loader):\n",
    "            data = data.to(device).float()\n",
    "            target = target.to(device).long()\n",
    "            output = net(data)\n",
    "            loss = criterion(output, target)\n",
    "            total_loss += loss.item()\n",
    "            prediction = torch.argmax(output, 1)\n",
    "            correct += (prediction == target).sum().item()\n",
    "            sample_num += len(prediction)\n",
    "    loss = total_loss / test_batch_num\n",
    "    acc = correct / sample_num\n",
    "    return loss, acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始训练------0-------------\n",
      "epoch:0\t train_loss:0.8417 \ttrain_acc: 0.6580 \ttest_loss: 1.0296 \t test_acc: 0.4088 \t training_time: 44.51\n",
      "开始训练------1-------------\n",
      "epoch:1\t train_loss:0.5769 \ttrain_acc: 0.8004 \ttest_loss: 0.9051 \t test_acc: 0.5794 \t training_time: 45.46\n",
      "开始训练------2-------------\n",
      "epoch:2\t train_loss:0.5139 \ttrain_acc: 0.8087 \ttest_loss: 0.8613 \t test_acc: 0.6441 \t training_time: 44.56\n",
      "开始训练------3-------------\n",
      "epoch:3\t train_loss:0.4567 \ttrain_acc: 0.8430 \ttest_loss: 0.6761 \t test_acc: 0.7206 \t training_time: 45.03\n",
      "开始训练------4-------------\n",
      "epoch:4\t train_loss:0.4162 \ttrain_acc: 0.8462 \ttest_loss: 0.5578 \t test_acc: 0.7588 \t training_time: 41.87\n",
      "开始训练------5-------------\n",
      "epoch:5\t train_loss:0.3865 \ttrain_acc: 0.8701 \ttest_loss: 0.4637 \t test_acc: 0.8265 \t training_time: 44.43\n",
      "开始训练------6-------------\n",
      "epoch:6\t train_loss:0.3520 \ttrain_acc: 0.8888 \ttest_loss: 0.4008 \t test_acc: 0.8324 \t training_time: 44.87\n",
      "开始训练------7-------------\n",
      "epoch:7\t train_loss:0.3342 \ttrain_acc: 0.9033 \ttest_loss: 0.4163 \t test_acc: 0.8353 \t training_time: 42.34\n",
      "开始训练------8-------------\n",
      "epoch:8\t train_loss:0.3120 \ttrain_acc: 0.9033 \ttest_loss: 0.3615 \t test_acc: 0.8588 \t training_time: 36.46\n",
      "开始训练------9-------------\n",
      "epoch:9\t train_loss:0.3019 \ttrain_acc: 0.9012 \ttest_loss: 0.4670 \t test_acc: 0.8176 \t training_time: 35.44\n",
      "开始训练------10-------------\n",
      "epoch:10\t train_loss:0.2999 \ttrain_acc: 0.9023 \ttest_loss: 0.3719 \t test_acc: 0.8676 \t training_time: 38.64\n",
      "开始训练------11-------------\n",
      "epoch:11\t train_loss:0.2801 \ttrain_acc: 0.9085 \ttest_loss: 0.3337 \t test_acc: 0.8735 \t training_time: 44.23\n",
      "开始训练------12-------------\n",
      "epoch:12\t train_loss:0.2694 \ttrain_acc: 0.9116 \ttest_loss: 0.3699 \t test_acc: 0.8500 \t training_time: 42.27\n",
      "开始训练------13-------------\n",
      "epoch:13\t train_loss:0.2677 \ttrain_acc: 0.9168 \ttest_loss: 0.3148 \t test_acc: 0.8765 \t training_time: 43.50\n",
      "开始训练------14-------------\n",
      "epoch:14\t train_loss:0.2673 \ttrain_acc: 0.9106 \ttest_loss: 0.2965 \t test_acc: 0.8941 \t training_time: 44.93\n",
      "开始训练------15-------------\n",
      "epoch:15\t train_loss:0.2556 \ttrain_acc: 0.9168 \ttest_loss: 0.2911 \t test_acc: 0.9000 \t training_time: 44.85\n",
      "开始训练------16-------------\n",
      "epoch:16\t train_loss:0.2522 \ttrain_acc: 0.9168 \ttest_loss: 0.3988 \t test_acc: 0.8559 \t training_time: 44.98\n",
      "开始训练------17-------------\n",
      "epoch:17\t train_loss:0.2387 \ttrain_acc: 0.9241 \ttest_loss: 0.2923 \t test_acc: 0.8765 \t training_time: 45.37\n",
      "开始训练------18-------------\n",
      "epoch:18\t train_loss:0.2167 \ttrain_acc: 0.9335 \ttest_loss: 0.3507 \t test_acc: 0.8706 \t training_time: 43.71\n",
      "开始训练------19-------------\n",
      "epoch:19\t train_loss:0.2255 \ttrain_acc: 0.9272 \ttest_loss: 0.2777 \t test_acc: 0.8882 \t training_time: 44.22\n"
     ]
    }
   ],
   "source": [
    "num_classes = 3\n",
    "epochs = 20\n",
    "lr = 0.001\n",
    "device = torch.device('cpu')\n",
    "# device = torch.device('cuda')\n",
    "\n",
    "net = ConvModule().to(device)\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(net.parameters(), lr = lr)\n",
    "\n",
    "train_loss_list = []\n",
    "train_acc_list = []\n",
    "test_loss_list = []\n",
    "test_acc_list = []\n",
    "training_time_list = []\n",
    "for epoch in range(epochs):\n",
    "    print(\"开始训练------\" + str(epoch) + \"-------------\")\n",
    "\n",
    "    start = time.time()  #开始时间\n",
    "    train_loss, train_acc = train_epoch(net, data_loader=train_loader, device=device)\n",
    "    end = time.time()  #结束时间\n",
    "    test_loss, test_acc = 0, 0\n",
    "    test_loss, test_acc  = test_epoch(net, data_loader=test_loader, device=device)\n",
    "    train_loss_list.append(train_loss)\n",
    "    train_acc_list.append(train_acc)\n",
    "    test_loss_list.append(test_loss)\n",
    "    test_acc_list.append(test_acc)\n",
    "    training_time_list.append(end - start)\n",
    "    print(f\"epoch:{epoch}\\t train_loss:{train_loss:.4f} \\t\"\n",
    "          f\"train_acc: {train_acc:.4f} \\t\"\n",
    "          f\"test_loss: {test_loss:.4f} \\t test_acc: {test_acc:.4f} \\t training_time: {end-start:.2f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始训练------20-------------\n",
      "epoch:20\t train_loss:0.2286 \ttrain_acc: 0.9324 \ttest_loss: 0.2685 \t test_acc: 0.9029 \t training_time: 44.41\n",
      "开始训练------21-------------\n",
      "epoch:21\t train_loss:0.2025 \ttrain_acc: 0.9366 \ttest_loss: 0.2565 \t test_acc: 0.9059 \t training_time: 44.56\n",
      "开始训练------22-------------\n",
      "epoch:24\t train_loss:0.2000 \ttrain_acc: 0.9314 \ttest_loss: 0.2123 \t test_acc: 0.9176 \t training_time: 44.91\n",
      "开始训练------25-------------\n",
      "epoch:25\t train_loss:0.1834 \ttrain_acc: 0.9459 \ttest_loss: 0.2598 \t test_acc: 0.8941 \t training_time: 42.16\n",
      "开始训练------26-------------\n",
      "epoch:26\t train_loss:0.1995 \ttrain_acc: 0.9293 \ttest_loss: 0.2323 \t test_acc: 0.9147 \t training_time: 45.19\n",
      "开始训练------27-------------\n",
      "epoch:27\t train_loss:0.1863 \ttrain_acc: 0.9345 \ttest_loss: 0.2313 \t test_acc: 0.9118 \t training_time: 45.08\n",
      "开始训练------28-------------\n",
      "epoch:28\t train_loss:0.1811 \ttrain_acc: 0.9335 \ttest_loss: 0.2490 \t test_acc: 0.9147 \t training_time: 44.81\n",
      "开始训练------29-------------\n",
      "epoch:29\t train_loss:0.1659 \ttrain_acc: 0.9418 \ttest_loss: 0.2137 \t test_acc: 0.9265 \t training_time: 44.43\n",
      "开始训练------30-------------\n",
      "epoch:30\t train_loss:0.1732 \ttrain_acc: 0.9376 \ttest_loss: 0.1957 \t test_acc: 0.9235 \t training_time: 44.24\n",
      "开始训练------31-------------\n",
      "epoch:31\t train_loss:0.1718 \ttrain_acc: 0.9428 \ttest_loss: 0.2516 \t test_acc: 0.9029 \t training_time: 44.77\n",
      "开始训练------32-------------\n",
      "epoch:32\t train_loss:0.1569 \ttrain_acc: 0.9522 \ttest_loss: 0.2186 \t test_acc: 0.9147 \t training_time: 45.21\n",
      "开始训练------33-------------\n",
      "epoch:33\t train_loss:0.1559 \ttrain_acc: 0.9480 \ttest_loss: 0.2009 \t test_acc: 0.9294 \t training_time: 41.54\n",
      "开始训练------34-------------\n",
      "epoch:34\t train_loss:0.1409 \ttrain_acc: 0.9584 \ttest_loss: 0.1731 \t test_acc: 0.9353 \t training_time: 44.46\n",
      "开始训练------35-------------\n",
      "epoch:35\t train_loss:0.1387 \ttrain_acc: 0.9574 \ttest_loss: 0.1883 \t test_acc: 0.9353 \t training_time: 45.67\n",
      "开始训练------36-------------\n",
      "epoch:36\t train_loss:0.1320 \ttrain_acc: 0.9595 \ttest_loss: 0.2396 \t test_acc: 0.9176 \t training_time: 45.03\n",
      "开始训练------37-------------\n",
      "epoch:37\t train_loss:0.1340 \ttrain_acc: 0.9626 \ttest_loss: 0.4890 \t test_acc: 0.8382 \t training_time: 44.30\n",
      "开始训练------38-------------\n",
      "epoch:38\t train_loss:0.1391 \ttrain_acc: 0.9543 \ttest_loss: 0.2037 \t test_acc: 0.9265 \t training_time: 44.17\n",
      "开始训练------39-------------\n",
      "epoch:39\t train_loss:0.1305 \ttrain_acc: 0.9563 \ttest_loss: 0.1984 \t test_acc: 0.9147 \t training_time: 44.84\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(epochs):\n",
    "    print(\"开始训练------\" + str(20 + epoch) + \"-------------\")\n",
    "\n",
    "    start = time.time()  #开始时间\n",
    "    train_loss, train_acc = train_epoch(net, data_loader=train_loader, device=device)\n",
    "    end = time.time()  #结束时间\n",
    "    test_loss, test_acc = 0, 0\n",
    "    test_loss, test_acc  = test_epoch(net, data_loader=test_loader, device=device)\n",
    "    train_loss_list.append(train_loss)\n",
    "    train_acc_list.append(train_acc)\n",
    "    test_loss_list.append(test_loss)\n",
    "    test_acc_list.append(test_acc)\n",
    "    training_time_list.append(end - start)\n",
    "    print(f\"epoch:{20 + epoch}\\t train_loss:{train_loss:.4f} \\t\"\n",
    "          f\"train_acc: {train_acc:.4f} \\t\"\n",
    "          f\"test_loss: {test_loss:.4f} \\t test_acc: {test_acc:.4f} \\t training_time: {end-start:.2f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "def plot(train_loss_list,label,title, subplot):\n",
    "    ax1 = plt.subplot(subplot)\n",
    "    plt.plot(list(range(len(train_loss_list))),train_loss_list, label=label)\n",
    "    ax1.set_title(title)\n",
    "    ax1.legend()\n",
    "#     plt.title(title)\n",
    "#     plt.legend()\n",
    "#     plt.show()\n",
    "plot(train_loss_list,\"train loss\",\"train loss\", 221)\n",
    "plot(test_loss_list,\"test loss\",\"test loss\", 222)\n",
    "plot(train_acc_list,\"train acc\",\"train acc\", 223)\n",
    "plot(test_acc_list,\"test acc\",\"test acc\", 224)\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvModule_5(nn.Module):\n",
    "    \"\"\"5层卷积\"\"\"\n",
    "    def __init__(self):\n",
    "        super(ConvModule_5, self).__init__()\n",
    "        self.conv = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=1, padding=0),\n",
    "            nn.BatchNorm2d(32),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=0),\n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=0),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, stride=1, padding=0),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, stride=1, padding=0),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(inplace=True),\n",
    "        )\n",
    "        self.fc = nn.Linear(128, num_classes)  # 因为上一层(avg_pool2d)输出为(16,128,3,2) \n",
    "#         self.fc = nn.Linear(128*3*2, num_classes)  # 因为上一层(avg_pool2d)输出为(16,128,3,2) \n",
    "    def forward(self, X):\n",
    "        # print(X.shape)\n",
    "        out = self.conv(X)\n",
    "#         print(out.shape)\n",
    "        out = F.avg_pool2d(out, kernel_size=30)  # 平均池化层将图片的大小变为1*1\n",
    "#         print(out.shape)\n",
    "        out = out.squeeze()  # squeeze 去除所有item数量为1的维度\n",
    "#         out = out.flatten(start_dim=1)  # flatten 将高维向量展平为 2 维向量\n",
    "        # out = out.view(-1, 128)\n",
    "        # print(out.shape)\n",
    "        out = self.fc(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始训练------0-------------\n",
      "epoch:0\t train_loss:0.6726 \ttrain_acc: 0.7152 \ttest_loss: 1.2944 \t test_acc: 0.2706 \t training_time: 42.22\n",
      "开始训练------1-------------\n",
      "epoch:1\t train_loss:0.4547 \ttrain_acc: 0.8306 \ttest_loss: 1.2916 \t test_acc: 0.4441 \t training_time: 42.70\n",
      "开始训练------2-------------\n",
      "epoch:2\t train_loss:0.3938 \ttrain_acc: 0.8638 \ttest_loss: 0.6624 \t test_acc: 0.7441 \t training_time: 42.35\n",
      "开始训练------3-------------\n",
      "epoch:3\t train_loss:0.3347 \ttrain_acc: 0.8773 \ttest_loss: 0.4959 \t test_acc: 0.7912 \t training_time: 42.33\n",
      "开始训练------4-------------\n",
      "epoch:4\t train_loss:0.3010 \ttrain_acc: 0.9012 \ttest_loss: 0.6459 \t test_acc: 0.7412 \t training_time: 42.13\n",
      "开始训练------5-------------\n",
      "epoch:5\t train_loss:0.2821 \ttrain_acc: 0.9096 \ttest_loss: 0.3836 \t test_acc: 0.8441 \t training_time: 42.30\n",
      "开始训练------6-------------\n",
      "epoch:6\t train_loss:0.2829 \ttrain_acc: 0.8971 \ttest_loss: 0.3865 \t test_acc: 0.8588 \t training_time: 42.47\n",
      "开始训练------7-------------\n",
      "epoch:7\t train_loss:0.2626 \ttrain_acc: 0.9158 \ttest_loss: 0.2918 \t test_acc: 0.8706 \t training_time: 42.28\n",
      "开始训练------8-------------\n",
      "epoch:8\t train_loss:0.2403 \ttrain_acc: 0.9179 \ttest_loss: 0.2809 \t test_acc: 0.8971 \t training_time: 42.19\n",
      "开始训练------9-------------\n",
      "epoch:9\t train_loss:0.2199 \ttrain_acc: 0.9335 \ttest_loss: 0.2974 \t test_acc: 0.8676 \t training_time: 42.02\n",
      "开始训练------10-------------\n",
      "epoch:10\t train_loss:0.2051 \ttrain_acc: 0.9345 \ttest_loss: 0.2412 \t test_acc: 0.9147 \t training_time: 41.84\n",
      "开始训练------11-------------\n",
      "epoch:11\t train_loss:0.1925 \ttrain_acc: 0.9335 \ttest_loss: 0.2848 \t test_acc: 0.8882 \t training_time: 42.13\n",
      "开始训练------12-------------\n",
      "epoch:12\t train_loss:0.1936 \ttrain_acc: 0.9356 \ttest_loss: 0.2555 \t test_acc: 0.8912 \t training_time: 42.15\n",
      "开始训练------13-------------\n",
      "epoch:13\t train_loss:0.1724 \ttrain_acc: 0.9418 \ttest_loss: 0.2863 \t test_acc: 0.8824 \t training_time: 42.50\n",
      "开始训练------14-------------\n",
      "epoch:14\t train_loss:0.1536 \ttrain_acc: 0.9511 \ttest_loss: 0.2547 \t test_acc: 0.9118 \t training_time: 44.66\n",
      "开始训练------15-------------\n",
      "epoch:15\t train_loss:0.1713 \ttrain_acc: 0.9345 \ttest_loss: 0.3152 \t test_acc: 0.8941 \t training_time: 42.24\n",
      "开始训练------16-------------\n",
      "epoch:16\t train_loss:0.1892 \ttrain_acc: 0.9428 \ttest_loss: 0.3215 \t test_acc: 0.8559 \t training_time: 42.22\n",
      "开始训练------17-------------\n",
      "epoch:17\t train_loss:0.1424 \ttrain_acc: 0.9532 \ttest_loss: 0.3535 \t test_acc: 0.8706 \t training_time: 42.06\n",
      "开始训练------18-------------\n",
      "epoch:18\t train_loss:0.1508 \ttrain_acc: 0.9480 \ttest_loss: 0.5579 \t test_acc: 0.7471 \t training_time: 42.17\n",
      "开始训练------19-------------\n",
      "epoch:19\t train_loss:0.1489 \ttrain_acc: 0.9439 \ttest_loss: 0.2352 \t test_acc: 0.9147 \t training_time: 42.36\n",
      "开始训练------20-------------\n",
      "epoch:20\t train_loss:0.1393 \ttrain_acc: 0.9574 \ttest_loss: 0.4124 \t test_acc: 0.8529 \t training_time: 42.48\n",
      "开始训练------21-------------\n",
      "epoch:21\t train_loss:0.1325 \ttrain_acc: 0.9511 \ttest_loss: 0.2719 \t test_acc: 0.8941 \t training_time: 42.52\n",
      "开始训练------22-------------\n",
      "epoch:22\t train_loss:0.1289 \ttrain_acc: 0.9615 \ttest_loss: 0.2211 \t test_acc: 0.9088 \t training_time: 42.03\n",
      "开始训练------23-------------\n",
      "epoch:23\t train_loss:0.1177 \ttrain_acc: 0.9595 \ttest_loss: 0.1658 \t test_acc: 0.9324 \t training_time: 42.24\n",
      "开始训练------24-------------\n",
      "epoch:26\t train_loss:0.0920 \ttrain_acc: 0.9709 \ttest_loss: 0.2960 \t test_acc: 0.8794 \t training_time: 42.01\n",
      "开始训练------27-------------\n",
      "epoch:27\t train_loss:0.0877 \ttrain_acc: 0.9730 \ttest_loss: 0.1803 \t test_acc: 0.9294 \t training_time: 41.91\n",
      "开始训练------28-------------\n",
      "epoch:28\t train_loss:0.0953 \ttrain_acc: 0.9667 \ttest_loss: 0.3078 \t test_acc: 0.8794 \t training_time: 42.15\n",
      "开始训练------29-------------\n",
      "epoch:29\t train_loss:0.1135 \ttrain_acc: 0.9595 \ttest_loss: 0.2913 \t test_acc: 0.8912 \t training_time: 42.26\n",
      "开始训练------30-------------\n",
      "epoch:30\t train_loss:0.1067 \ttrain_acc: 0.9584 \ttest_loss: 0.2503 \t test_acc: 0.9000 \t training_time: 42.40\n",
      "开始训练------31-------------\n",
      "epoch:31\t train_loss:0.0923 \ttrain_acc: 0.9761 \ttest_loss: 0.2076 \t test_acc: 0.9265 \t training_time: 42.83\n",
      "开始训练------32-------------\n",
      "epoch:32\t train_loss:0.0729 \ttrain_acc: 0.9771 \ttest_loss: 0.2179 \t test_acc: 0.9118 \t training_time: 42.21\n",
      "开始训练------33-------------\n",
      "epoch:33\t train_loss:0.0627 \ttrain_acc: 0.9792 \ttest_loss: 0.7197 \t test_acc: 0.7676 \t training_time: 42.54\n",
      "开始训练------34-------------\n",
      "epoch:34\t train_loss:0.0538 \ttrain_acc: 0.9834 \ttest_loss: 0.2124 \t test_acc: 0.9147 \t training_time: 42.25\n",
      "开始训练------35-------------\n",
      "epoch:35\t train_loss:0.0479 \ttrain_acc: 0.9834 \ttest_loss: 0.2250 \t test_acc: 0.9176 \t training_time: 42.08\n",
      "开始训练------36-------------\n",
      "epoch:38\t train_loss:0.0499 \ttrain_acc: 0.9823 \ttest_loss: 0.5322 \t test_acc: 0.8206 \t training_time: 42.79\n",
      "开始训练------39-------------\n",
      "epoch:39\t train_loss:0.0625 \ttrain_acc: 0.9792 \ttest_loss: 0.2696 \t test_acc: 0.9088 \t training_time: 42.45\n"
     ]
    }
   ],
   "source": [
    "net = ConvModule_5().to(device)\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(net.parameters(), lr = lr)\n",
    "train_loss_list_conv5 = []\n",
    "train_acc_list_conv5 = []\n",
    "test_loss_list_conv5 = []\n",
    "test_acc_list_conv5 = []\n",
    "training_time_list_conv5 = []\n",
    "epochs = 40\n",
    "for epoch in range(epochs):\n",
    "    print(\"开始训练------\" + str(epoch) + \"-------------\")\n",
    "\n",
    "    start = time.time()  #开始时间\n",
    "    train_loss, train_acc = train_epoch(net, data_loader=train_loader, device=device)\n",
    "    end = time.time()  #结束时间\n",
    "    test_loss, test_acc  = test_epoch(net, data_loader=test_loader, device=device)\n",
    "    train_loss_list_conv5.append(train_loss)\n",
    "    train_acc_list_conv5.append(train_acc)\n",
    "    test_loss_list_conv5.append(test_loss)\n",
    "    test_acc_list_conv5.append(test_acc)\n",
    "    training_time_list_conv5.append(end - start)\n",
    "    print(f\"epoch:{epoch}\\t train_loss:{train_loss:.4f} \\t\"\n",
    "          f\"train_acc: {train_acc:.4f} \\t\"\n",
    "          f\"test_loss: {test_loss:.4f} \\t test_acc: {test_acc:.4f} \\t training_time: {end-start:.2f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "def plot(train_loss_list,train_loss_list_conv5,title, subplot):\n",
    "    ax1 = plt.subplot(subplot)\n",
    "    plt.plot(list(range(len(train_loss_list))),train_loss_list, label=\"conv3\")\n",
    "    plt.plot(list(range(len(train_loss_list_conv5))),train_loss_list_conv5, label=\"conv5\")\n",
    "    ax1.set_title(title)\n",
    "    ax1.legend()\n",
    "#     plt.title(title)\n",
    "#     plt.legend()\n",
    "#     plt.show()\n",
    "plot(train_loss_list,train_loss_list_conv5,\"train loss\", 221)\n",
    "plot(test_loss_list,test_loss_list_conv5,\"test loss\", 222)\n",
    "plot(train_acc_list,train_acc_list_conv5,\"train acc\", 223)\n",
    "plot(test_acc_list,test_acc_list_conv5,\"test acc\", 224)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvModule_dilation(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(ConvModule_dilation, self).__init__()\n",
    "        self.conv = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=1, padding=0, dilation = 1),\n",
    "            nn.BatchNorm2d(32),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=0, dilation = 2),\n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=0, dilation = 5),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(inplace=True)\n",
    "        )\n",
    "        self.fc = nn.Linear(128, num_classes)  # 上一层(avg_pool2d)输出为(16,128,3,2) \n",
    "#         self.fc = nn.Linear(128*3*2, num_classes)  # 上一层(avg_pool2d)输出为(16,128,3,2) \n",
    "    def forward(self, X):\n",
    "        # print(X.shape)\n",
    "        out = self.conv(X)\n",
    "#         print(out.shape)\n",
    "        out = F.avg_pool2d(out, kernel_size=30)  # 平均池化层将图片的大小变为1*1\n",
    "#         print(out.shape)\n",
    "        out = out.squeeze()  # squeeze 去除所有item数量为1的维度\n",
    "#         out = out.flatten(start_dim=1)  # flatten 将高维向量展平为 2 维向量\n",
    "        # out = out.view(-1, 128)\n",
    "        # print(out.shape)\n",
    "        out = self.fc(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始训练------0-------------\n",
      "epoch:0\t train_loss:0.7619 \ttrain_acc: 0.6746 \ttest_loss: 0.9864 \t test_acc: 0.6088 \t training_time: 21.90\n",
      "开始训练------1-------------\n",
      "epoch:1\t train_loss:0.5163 \ttrain_acc: 0.8150 \ttest_loss: 0.9952 \t test_acc: 0.4618 \t training_time: 21.86\n",
      "开始训练------2-------------\n",
      "epoch:2\t train_loss:0.4546 \ttrain_acc: 0.8389 \ttest_loss: 0.8264 \t test_acc: 0.6412 \t training_time: 26.74\n",
      "开始训练------3-------------\n",
      "epoch:3\t train_loss:0.3820 \ttrain_acc: 0.8597 \ttest_loss: 0.5753 \t test_acc: 0.7676 \t training_time: 26.54\n",
      "开始训练------4-------------\n",
      "epoch:4\t train_loss:0.3509 \ttrain_acc: 0.8742 \ttest_loss: 0.4749 \t test_acc: 0.8059 \t training_time: 22.01\n",
      "开始训练------5-------------\n",
      "epoch:5\t train_loss:0.3282 \ttrain_acc: 0.8784 \ttest_loss: 0.3770 \t test_acc: 0.8647 \t training_time: 40.16\n",
      "开始训练------6-------------\n",
      "epoch:6\t train_loss:0.3308 \ttrain_acc: 0.8909 \ttest_loss: 0.3602 \t test_acc: 0.8618 \t training_time: 61.45\n",
      "开始训练------7-------------\n",
      "epoch:7\t train_loss:0.3031 \ttrain_acc: 0.9002 \ttest_loss: 0.3270 \t test_acc: 0.8706 \t training_time: 72.58\n",
      "开始训练------8-------------\n",
      "epoch:8\t train_loss:0.2831 \ttrain_acc: 0.9106 \ttest_loss: 0.3645 \t test_acc: 0.8412 \t training_time: 70.36\n",
      "开始训练------9-------------\n",
      "epoch:9\t train_loss:0.2651 \ttrain_acc: 0.9137 \ttest_loss: 0.3083 \t test_acc: 0.8824 \t training_time: 60.13\n",
      "开始训练------10-------------\n",
      "epoch:10\t train_loss:0.2429 \ttrain_acc: 0.9231 \ttest_loss: 0.3278 \t test_acc: 0.8912 \t training_time: 64.81\n",
      "开始训练------11-------------\n",
      "epoch:11\t train_loss:0.2312 \ttrain_acc: 0.9262 \ttest_loss: 0.2608 \t test_acc: 0.8971 \t training_time: 57.97\n",
      "开始训练------12-------------\n",
      "epoch:12\t train_loss:0.2130 \ttrain_acc: 0.9366 \ttest_loss: 0.2931 \t test_acc: 0.8912 \t training_time: 54.72\n",
      "开始训练------13-------------\n",
      "epoch:13\t train_loss:0.2196 \ttrain_acc: 0.9252 \ttest_loss: 0.2723 \t test_acc: 0.8971 \t training_time: 22.06\n",
      "开始训练------14-------------\n",
      "epoch:14\t train_loss:0.2111 \ttrain_acc: 0.9283 \ttest_loss: 0.2642 \t test_acc: 0.9000 \t training_time: 22.06\n",
      "开始训练------15-------------\n",
      "epoch:15\t train_loss:0.1925 \ttrain_acc: 0.9387 \ttest_loss: 0.2214 \t test_acc: 0.9206 \t training_time: 22.16\n",
      "开始训练------16-------------\n",
      "epoch:16\t train_loss:0.1864 \ttrain_acc: 0.9397 \ttest_loss: 0.2282 \t test_acc: 0.9000 \t training_time: 48.50\n",
      "开始训练------17-------------\n",
      "epoch:17\t train_loss:0.1736 \ttrain_acc: 0.9387 \ttest_loss: 0.2261 \t test_acc: 0.9206 \t training_time: 22.21\n",
      "开始训练------18-------------\n",
      "epoch:18\t train_loss:0.1818 \ttrain_acc: 0.9314 \ttest_loss: 0.2245 \t test_acc: 0.9176 \t training_time: 22.98\n",
      "开始训练------19-------------\n",
      "epoch:19\t train_loss:0.1581 \ttrain_acc: 0.9449 \ttest_loss: 0.1897 \t test_acc: 0.9265 \t training_time: 22.62\n"
     ]
    }
   ],
   "source": [
    "num_classes = 3\n",
    "epochs = 20\n",
    "lr = 0.001\n",
    "device = torch.device('cpu')\n",
    "# device = torch.device('cuda')\n",
    "\n",
    "net_dilation = ConvModule_dilation().to(device)\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(net_dilation.parameters(), lr = lr)\n",
    "\n",
    "train_loss_list_dilation = []\n",
    "train_acc_list_dilation = []\n",
    "test_loss_list_dilation = []\n",
    "test_acc_list_dilation = []\n",
    "training_time_list_dilation = []\n",
    "for epoch in range(epochs):\n",
    "    print(\"开始训练------\" + str(epoch) + \"-------------\")\n",
    "\n",
    "    start = time.time()  #开始时间\n",
    "    train_loss, train_acc = train_epoch(net_dilation, data_loader=train_loader, device=device)\n",
    "    end = time.time()  #结束时间\n",
    "    test_loss, test_acc = 0, 0\n",
    "    test_loss, test_acc  = test_epoch(net_dilation, data_loader=test_loader, device=device)\n",
    "    train_loss_list.append(train_loss)\n",
    "    train_acc_list.append(train_acc)\n",
    "    test_loss_list.append(test_loss)\n",
    "    test_acc_list.append(test_acc)\n",
    "    training_time_list.append(end - start)\n",
    "    print(f\"epoch:{epoch}\\t train_loss:{train_loss:.4f} \\t\"\n",
    "          f\"train_acc: {train_acc:.4f} \\t\"\n",
    "          f\"test_loss: {test_loss:.4f} \\t test_acc: {test_acc:.4f} \\t training_time: {end-start:.2f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "开始训练------0-------------\n",
      "epoch:0\t train_loss:0.1588 \ttrain_acc: 0.9501 \ttest_loss: 0.2141 \t test_acc: 0.9294 \t training_time: 68.27\n",
      "开始训练------1-------------\n",
      "epoch:1\t train_loss:0.1624 \ttrain_acc: 0.9418 \ttest_loss: 0.2411 \t test_acc: 0.8882 \t training_time: 73.51\n",
      "开始训练------2-------------\n",
      "epoch:2\t train_loss:0.1966 \ttrain_acc: 0.9272 \ttest_loss: 0.2733 \t test_acc: 0.9000 \t training_time: 68.43\n",
      "开始训练------3-------------\n",
      "epoch:3\t train_loss:0.1672 \ttrain_acc: 0.9366 \ttest_loss: 0.2773 \t test_acc: 0.9000 \t training_time: 63.71\n",
      "开始训练------4-------------\n",
      "epoch:4\t train_loss:0.1594 \ttrain_acc: 0.9376 \ttest_loss: 0.2038 \t test_acc: 0.9294 \t training_time: 22.18\n",
      "开始训练------5-------------\n",
      "epoch:5\t train_loss:0.1524 \ttrain_acc: 0.9501 \ttest_loss: 0.1999 \t test_acc: 0.9324 \t training_time: 22.17\n",
      "开始训练------6-------------\n",
      "epoch:6\t train_loss:0.1342 \ttrain_acc: 0.9563 \ttest_loss: 0.1886 \t test_acc: 0.9265 \t training_time: 22.04\n",
      "开始训练------7-------------\n",
      "epoch:7\t train_loss:0.1289 \ttrain_acc: 0.9511 \ttest_loss: 0.1757 \t test_acc: 0.9353 \t training_time: 21.97\n",
      "开始训练------8-------------\n",
      "epoch:8\t train_loss:0.1186 \ttrain_acc: 0.9605 \ttest_loss: 0.1652 \t test_acc: 0.9294 \t training_time: 21.93\n",
      "开始训练------9-------------\n",
      "epoch:9\t train_loss:0.1188 \ttrain_acc: 0.9605 \ttest_loss: 0.1571 \t test_acc: 0.9500 \t training_time: 22.10\n",
      "开始训练------10-------------\n",
      "epoch:10\t train_loss:0.1255 \ttrain_acc: 0.9615 \ttest_loss: 0.1703 \t test_acc: 0.9265 \t training_time: 22.47\n",
      "开始训练------11-------------\n",
      "epoch:11\t train_loss:0.1269 \ttrain_acc: 0.9553 \ttest_loss: 0.2339 \t test_acc: 0.9147 \t training_time: 21.95\n",
      "开始训练------12-------------\n",
      "epoch:12\t train_loss:0.1188 \ttrain_acc: 0.9595 \ttest_loss: 0.1693 \t test_acc: 0.9441 \t training_time: 22.32\n",
      "开始训练------13-------------\n",
      "epoch:13\t train_loss:0.1072 \ttrain_acc: 0.9636 \ttest_loss: 0.1561 \t test_acc: 0.9353 \t training_time: 22.34\n",
      "开始训练------14-------------\n",
      "epoch:14\t train_loss:0.0985 \ttrain_acc: 0.9647 \ttest_loss: 0.1557 \t test_acc: 0.9353 \t training_time: 22.65\n",
      "开始训练------15-------------\n",
      "epoch:15\t train_loss:0.0921 \ttrain_acc: 0.9771 \ttest_loss: 0.1548 \t test_acc: 0.9441 \t training_time: 22.19\n",
      "开始训练------16-------------\n",
      "epoch:16\t train_loss:0.0867 \ttrain_acc: 0.9719 \ttest_loss: 0.1682 \t test_acc: 0.9294 \t training_time: 22.10\n",
      "开始训练------17-------------\n",
      "epoch:17\t train_loss:0.0870 \ttrain_acc: 0.9688 \ttest_loss: 0.1430 \t test_acc: 0.9471 \t training_time: 22.08\n",
      "开始训练------18-------------\n",
      "epoch:18\t train_loss:0.0834 \ttrain_acc: 0.9740 \ttest_loss: 0.1524 \t test_acc: 0.9441 \t training_time: 22.08\n",
      "开始训练------19-------------\n",
      "epoch:19\t train_loss:0.0806 \ttrain_acc: 0.9688 \ttest_loss: 0.1534 \t test_acc: 0.9500 \t training_time: 22.39\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(epochs):\n",
    "    print(\"开始训练------\" + str(epoch) + \"-------------\")\n",
    "\n",
    "    start = time.time()  #开始时间\n",
    "    train_loss, train_acc = train_epoch(net_dilation, data_loader=train_loader, device=device)\n",
    "    end = time.time()  #结束时间\n",
    "    test_loss, test_acc = 0, 0\n",
    "    test_loss, test_acc  = test_epoch(net_dilation, data_loader=test_loader, device=device)\n",
    "    train_loss_list.append(train_loss)\n",
    "    train_acc_list.append(train_acc)\n",
    "    test_loss_list.append(test_loss)\n",
    "    test_acc_list.append(test_acc)\n",
    "    training_time_list.append(end - start)\n",
    "    print(f\"epoch:{epoch}\\t train_loss:{train_loss:.4f} \\t\"\n",
    "          f\"train_acc: {train_acc:.4f} \\t\"\n",
    "          f\"test_loss: {test_loss:.4f} \\t test_acc: {test_acc:.4f} \\t training_time: {end-start:.2f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "92\n"
     ]
    }
   ],
   "source": [
    "# print(len(test_acc_list))\n",
    "# print(test_acc_list[-20:])\n",
    "# print(test_acc_list[-40:-20])\n",
    "# print(test_acc_list[-40:])\n",
    "# print(test_acc_list[:40])\n",
    "train_loss_list_dilation = train_loss_list[-40:]\n",
    "train_acc_list_dilation = train_acc_list[-40:]\n",
    "test_loss_list_dilation = test_loss_list[-40:]\n",
    "test_acc_list_dilation = test_acc_list[-40:]\n",
    "training_time_list_dilation = training_time_list[-40:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "def plot(train_loss_list,train_loss_list_conv5,title, subplot):\n",
    "    ax1 = plt.subplot(subplot)\n",
    "    plt.plot(list(range(len(train_loss_list))),train_loss_list, label=\"without dilation\")\n",
    "    plt.plot(list(range(len(train_loss_list_conv5))),train_loss_list_conv5, label=\"HDC dilation\")\n",
    "    ax1.set_title(title)\n",
    "    ax1.legend()\n",
    "#     plt.title(title)\n",
    "#     plt.legend()\n",
    "#     plt.show()\n",
    "plot(train_loss_list[:40],train_loss_list_dilation,\"train loss\", 221)\n",
    "plot(test_loss_list[:40],test_loss_list_dilation,\"test loss\", 222)\n",
    "plot(train_acc_list[:40],train_acc_list_dilation,\"train acc\", 223)\n",
    "plot(test_acc_list[:40],test_acc_list_dilation,\"test acc\", 224)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}